home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 24 / Amiga Format AFCD24 (Feb 1998, Issue 108).iso / -in_the_mag- / emulation / amiga / uae-0.7.0b2 / src / tui.c < prev    next >
C/C++ Source or Header  |  1998-01-20  |  16KB  |  655 lines
  1.  /*
  2.   * UAE - The Un*x Amiga Emulator
  3.   *
  4.   * Text-based user interface
  5.   * Sie haben es sich verdient!
  6.   *
  7.   * Copyright 1996 Tim Gunn, Bernd Schmidt
  8.   */
  9.  
  10. #include "sysconfig.h"
  11. #include "sysdeps.h"
  12.  
  13. #include <stdio.h>
  14. #include <ctype.h>
  15.  
  16. #include "config.h"
  17. #include "options.h"
  18. #include "threaddep/penguin.h"
  19. #include "uae.h"
  20. #include "gensound.h"
  21. #include "joystick.h"
  22. #include "keybuf.h"
  23. #include "autoconf.h"
  24. #include "xwin.h"
  25. #include "tui.h"
  26. #include "gui.h"
  27. #include "memory.h"
  28.  
  29. #define MAX_MENU_HEIGHT 15
  30. #define OPTION_COLUMN 3
  31. #define MENU_COL_OFFSET -2
  32.  
  33. int mountok=0;
  34.  
  35. void gui_led(int led, int on)
  36. {
  37. }
  38. void gui_filename(int num, const char *name)
  39. {
  40. }
  41. static void getline(char *p)
  42. {
  43. }
  44. void gui_handle_events(void)
  45. {
  46. }
  47.  
  48. void gui_exit()
  49. {
  50.     if (currprefs.allow_save) {
  51.     FILE *f;
  52.     tui_backup_optionsfile();
  53.     f = fopen(optionsfile, "w");
  54.     if (f == NULL) {
  55.         fprintf(stderr, "Error saving options file!\n");
  56.         return;
  57.     }
  58.     save_options(f);
  59.     fclose(f);
  60.     }
  61. }
  62.  
  63. static struct bstring mainmenu[] = {
  64.     { "UAE configuration", 0 },
  65.     { "_Disk settings", 'D' },
  66.     { "_Video settings", 'V' },
  67.     { "_Memory settings", 'M' },
  68.     { "_Hard disk settings", 'H' },
  69.     { "_Sound settings", 'S' },
  70.     { "_Other settings", 'O' },
  71.     { "_Run UAE", 'R' },
  72.     { NULL, -3 }
  73. };
  74.  
  75. static struct bstring mainmenu2[] = {
  76.     { "UAE configuration", 0 },
  77.     { "_Disk settings", 'D' },
  78. /*    { "_Video settings", 'V' },
  79.     { "_Memory settings", 'M' },
  80.     { "_Hard disk settings", 'H' },
  81.     { "_Sound settings", 'S' }, */
  82.     { "_Other settings", 'O' },
  83.     { "R_eset UAE", 'E' },
  84.     { "_Quit UAE", 'Q' },
  85.     { "_Run UAE", 'R' },
  86.     { NULL, -3 }
  87. };
  88.  
  89. static struct bstring diskmenu[] = {
  90.     { "Floppy disk settings", 0 },
  91.     { "Change DF_0:", '0' },
  92.     { "Change DF_1:", '1' },
  93.     { "Change DF_2:", '2' },
  94.     { "Change DF_3:", '3' },
  95.     { NULL, -3 }
  96. };
  97.  
  98. static struct bstring videomenu[] = {
  99.     { "Video settings", 0 },
  100.     { "Change _width", 'W' },
  101.     { "Change _height", 'H' },
  102.     { "Change _color mode", 'C' },
  103.     { "Select predefined _mode", 'M' },
  104.     { "Toggle _low resolution", 'L' },
  105.     { "Change _X centering", 'X' },
  106.     { "Change _Y centering", 'Y' },
  107.     { "Toggle line _doubling", 'D' },
  108.     { "Toggle _aspect _correction", 'A' },
  109.     { "Change _framerate", 'F' },
  110.     { NULL, -3 }
  111. };
  112.  
  113. static struct bstring memorymenu[] = {
  114.     { "Memory settings", 0 },
  115.     { "Change _fastmem size", 'F' },
  116.     { "Change _chipmem size", 'C' },
  117.     { "Change _slowmem size", 'S' },
  118.     { "Select ROM _image", 'I' },
  119.     { NULL, -3 }
  120. };
  121.  
  122. static struct bstring soundmenu[] = {
  123.     { "Sound settings", 0 },
  124.     { "Change _sound emulation accuracy", 'S' },
  125.     { "Change m_inimum sound buffer size", 'I' },
  126.     { "Change m_aximum sound buffer size", 'A' },
  127.     { "Change number of _bits", 'B' },
  128.     { "Change output _frequency", 'F' },
  129.     { NULL , -3 }
  130. };
  131.  
  132. static struct bstring miscmenu[] = {
  133.     { "Miscellaneous settings", 0 },
  134.     { "Toggle joystick port _0 emulation", '0' },
  135.     { "Toggle joystick port _1 emulation", '1' },
  136.     { "Set _CPU emulation speed", 'C' },
  137.     { NULL, -3 }
  138. };
  139.  
  140. static struct bstring hdmenu[] = {
  141. /*    { "Harddisk/CDROM emulation settings", 0 },*/
  142.     { "Enable/Disable _harddisks/fastmem", 'H' },
  143.     { "_Add a mounted volume", 'A' },
  144.     { "Add a mounted _volume r/o", 'V' },
  145.     { "Add a hard_file", 'F' },
  146.     { "_Delete a mounted volume", 'D' },
  147.     { NULL, -3 }
  148. };
  149.  
  150. static int makemenu(const char **menu, int x, int y)
  151. {
  152.     const char **m = menu;
  153.     int maxlen = 0, count = 0;
  154.     int w;
  155.  
  156.     while (*m != NULL) {
  157.     int l = strlen(*m);
  158.     if (l > maxlen)
  159.         maxlen = l;
  160.     m++; count++;
  161.     }
  162.     w = tui_dlog(x, y, x + maxlen + 2, y + count + 1);
  163.     tui_drawbox(w);
  164.     tui_selwin(w);
  165.     y = 2;
  166.     while (*menu != NULL) {
  167.     tui_gotoxy(2, y++);
  168.     tui_puts(*menu++);
  169.     }
  170.     tui_selwin(0);
  171.     return w;
  172. }
  173.  
  174. static char tmpbuf[256];
  175.  
  176. static char *trimfilename(char *s, size_t n)
  177. {
  178.     size_t i;
  179.     if (n > 250)
  180.     n = 250;
  181.     if (strlen(s) == 0)
  182.     strcpy(tmpbuf, "none");
  183.     else if (strlen(s) < n)
  184.     strcpy(tmpbuf, s);
  185.     else {
  186.     tmpbuf[0] = '^';
  187.     strcpy(tmpbuf + 1, s + strlen(s) - n + 2);
  188.     }
  189.     for (i = strlen(tmpbuf); i < n; i++)
  190.     tmpbuf[i] = ' ';
  191.     tmpbuf[i] = 0;
  192.     return tmpbuf;
  193. }
  194.  
  195. static void print_configuration(void)
  196. {
  197.     char tmp[256];
  198.     int y = 5;
  199.     int i;
  200.  
  201.     tui_clrwin(0);
  202.  
  203.     tui_drawbox(0);
  204.     tui_hline(2, 3, tui_cols() - 1);
  205.     sprintf(tmp, "UAE %d.%d.%d: The Un*x Amiga Emulator", UAEMAJOR, UAEMINOR, UAEURSAMINOR);
  206.     tui_gotoxy((tui_cols() - strlen(tmp))/2, 2); tui_puts(tmp);
  207.     strcpy(tmp, "Press RETURN/ENTER to run UAE, ESC to exit");
  208.     tui_gotoxy((tui_cols() - strlen(tmp))/2, tui_lines()); tui_puts(tmp);
  209.  
  210.     tui_gotoxy(OPTION_COLUMN, y++); sprintf(tmp, "Disk file DF0: %s", trimfilename(currprefs.df[0], tui_cols() - 20)); tui_puts(tmp);
  211.     tui_gotoxy(OPTION_COLUMN, y++); sprintf(tmp, "Disk file DF1: %s", trimfilename(currprefs.df[1], tui_cols() - 20)); tui_puts(tmp);
  212.     tui_gotoxy(OPTION_COLUMN, y++); sprintf(tmp, "Disk file DF2: %s", trimfilename(currprefs.df[2], tui_cols() - 20)); tui_puts(tmp);
  213.     tui_gotoxy(OPTION_COLUMN, y++); sprintf(tmp, "Disk file DF3: %s", trimfilename(currprefs.df[3], tui_cols() - 20)); tui_puts(tmp);
  214.     y++;
  215.     tui_gotoxy(OPTION_COLUMN, y++);
  216.     sprintf(tmp, "VIDEO: %d:%d%s %s", currprefs.gfx_width, currprefs.gfx_height,
  217.         currprefs.gfx_lores ? " (lores)" : "", colormodes[currprefs.color_mode]);
  218.     tui_puts(tmp);
  219.  
  220.     tui_gotoxy(OPTION_COLUMN+7, y++);
  221.     if (currprefs.gfx_linedbl)
  222.     tui_puts("Doubling lines, ");
  223.     if (currprefs.gfx_correct_aspect)
  224.     tui_puts("Aspect corrected");
  225.     else
  226.     tui_puts("Not aspect corrected");
  227.     tui_gotoxy(OPTION_COLUMN+7, y++);
  228.     if (currprefs.gfx_xcenter)
  229.     tui_puts ("X centered");
  230.     if (currprefs.gfx_xcenter == 2)
  231.     tui_puts (" (clever)");
  232.     if (currprefs.gfx_ycenter && currprefs.gfx_xcenter)
  233.     tui_puts (", ");
  234.     if (currprefs.gfx_ycenter)
  235.     tui_puts ("Y centered ");
  236.     if (currprefs.gfx_ycenter == 2)
  237.     tui_puts (" (clever)");
  238.     tui_gotoxy(OPTION_COLUMN+7, y++);
  239.     tui_puts("drawing every ");
  240.     switch(currprefs.framerate) {
  241.      case 1: break;
  242.      case 2: tui_puts("2nd "); break;
  243.      case 3: tui_puts("3rd "); break;
  244.      default: sprintf(tmp, "%dth ",currprefs.framerate); tui_puts(tmp); break;
  245.     }
  246.     tui_puts("frame.    ");
  247.     y++;
  248.     tui_gotoxy(OPTION_COLUMN, y++);
  249.     sprintf(tmp, "MEMORY: %4dK chip; %4dK fast; %4dK slow",chipmem_size/1024,fastmem_size/1024,bogomem_size/1024);
  250.     tui_puts(tmp);
  251.  
  252.     tui_gotoxy(OPTION_COLUMN, y++);
  253.     sprintf(tmp, "ROM IMAGE: %s", trimfilename(romfile, tui_cols() - 50));
  254.     tui_puts(tmp);
  255.     tui_gotoxy(OPTION_COLUMN, y++);
  256.     if (!sound_available)
  257.     tui_puts("SOUND: Not available");
  258.     else {
  259.     switch (currprefs.produce_sound) {
  260.      case 0: tui_puts("SOUND: 0 (Off)"); break;
  261.      case 1: tui_puts("SOUND: 1 (Off, but emulated)"); break;
  262.      case 2: tui_puts("SOUND: 2 (On)"); break;
  263.      case 3: tui_puts("SOUND: 3 (On, emulated perfectly)"); break;
  264.     }
  265.     tui_gotoxy(OPTION_COLUMN + 7, y++);
  266.     sprintf(tmp, "%d bits at %d Hz", currprefs.sound_bits, currprefs.sound_freq);
  267.     tui_puts(tmp);
  268.     tui_gotoxy(OPTION_COLUMN + 7, y++);
  269.     sprintf(tmp, "Minimum buffer size %d bytes, maximum %d bytes", currprefs.sound_minbsiz, currprefs.sound_maxbsiz);
  270.     tui_puts(tmp);
  271.     }
  272.  
  273.     tui_gotoxy(OPTION_COLUMN,y++);
  274.     tui_puts ("GAME PORT 1: "); tui_puts (gameport_state (0));
  275.     tui_gotoxy(OPTION_COLUMN,y++);
  276.     tui_puts ("GAME PORT 2: "); tui_puts (gameport_state (1));
  277.  
  278.     tui_gotoxy(OPTION_COLUMN,y++);
  279.     sprintf(tmp, "HARDDISK: (%s)", currprefs.automount_uaedev ? "enabled" : "disabled");
  280.     tui_puts(tmp);
  281.  
  282.     for (i = 0;; i++) {
  283.     char buf[256];
  284.  
  285.     tui_gotoxy(OPTION_COLUMN+1,y++);
  286.     if (sprintf_filesys_unit(buf, i) == -1)
  287.         break;
  288.     tui_puts(buf);
  289.     }
  290. }
  291.  
  292. static void HDOptions(void)
  293. {
  294.     char *buff;
  295.     char tmp[256];
  296.     char mountvol[256];
  297.     char mountdir[256];
  298.     int c = 0;
  299.  
  300.     for (;;){
  301.  
  302.     tui_selwin(0);
  303.     print_configuration();
  304.  
  305.     c = tui_menubrowse (hdmenu, MENU_COL_OFFSET, 5, c, MAX_MENU_HEIGHT);
  306.     if (c == -1)
  307.         break;
  308.     else switch(c) {
  309.      case 0:
  310.         currprefs.automount_uaedev = !currprefs.automount_uaedev;
  311.         break;
  312.      case 1:
  313.         tui_wgets (mountvol, "Enter mounted volume name", 10);
  314.         if (strlen (mountvol) == 0)
  315.         break;
  316.         if (mountvol[strlen(mountvol)-1]==':')
  317.         mountvol[strlen(mountvol)-1] = 0;
  318.         tui_wgets (mountdir, "Enter mounted volume path", 78);
  319.         add_filesys_unit (mountvol, mountdir, 0, 0, 0, 0);
  320.         break;
  321.      case 2:
  322.         tui_wgets (mountvol, "Enter mounted volume name", 10);
  323.         if (strlen (mountvol) == 0)
  324.         break;
  325.         if(mountvol[strlen (mountvol)-1]==':')
  326.         mountvol[strlen (mountvol)-1] = 0;
  327.         tui_wgets (mountdir, "Enter mounted volume path", 78);
  328.         add_filesys_unit (mountvol, mountdir, 1, 0, 0, 0);
  329.         break;
  330.      case 3:
  331.         buff = tui_filereq("*", "", "Select the hardfile to be mounted");
  332.         if (buff == NULL)
  333.         break;
  334.         strcpy (mountvol, buff);
  335.         tui_wgets (mountdir, "Enter number of sectors per track", 4);
  336.         tui_wgets (mountdir + 10, "Enter number of heads", 4);
  337.         tui_wgets (mountdir + 20, "Enter number of reserved blocks", 3);
  338.         buff = add_filesys_unit (0, mountvol, 1,
  339.                      atoi (mountdir), atoi (mountdir + 10),
  340.                      atoi (mountdir + 20));
  341.         if (buff)
  342.         tui_errorbox (buff);
  343.         break;
  344.      case 4:
  345.         tui_wgets (mountvol, "Enter number of volume to be removed (0 for UAE0:, etc.)", 2);
  346.         if (kill_filesys_unit (atoi (mountvol)) == -1)
  347.         tui_errorbox("Volume does not exist");
  348.         break;
  349.     }
  350.     }
  351. }
  352.  
  353. static void DiskOptions(void)
  354. {
  355.     char tmp[256];
  356.     int c = 0;
  357.  
  358.     for (;;) {
  359.     char *sel;
  360.  
  361.     tui_selwin(0);
  362.     print_configuration();
  363.  
  364.     c = tui_menubrowse(diskmenu, MENU_COL_OFFSET, 5, c, MAX_MENU_HEIGHT);
  365.     if (c == -1)
  366.         break;
  367.     else switch(c) {
  368.      case 0:
  369.      case 1:
  370.      case 2:
  371.      case 3:
  372.         sprintf(tmp, "Select a diskfile for DF%d:", c);
  373.         sel = tui_filereq("*.adf", currprefs.df[c], tmp);
  374.         if (sel == NULL)
  375.         break;
  376.         strcpy(currprefs.df[c], sel);
  377.         break;
  378.     }
  379.     }
  380. }
  381.  
  382. static void VideoOptions(void)
  383. {
  384.     char tmp[256];
  385.     int c = 0;
  386.  
  387.     for (c = 0; c < 10; c++)
  388.     if (videomenu[c].val == 'M') {
  389.         if (video_mode_menu == NULL)
  390.         videomenu[c].val = -4;
  391.         break;
  392.     }
  393.  
  394.     c = 0;
  395.     for (;;) {
  396.  
  397.     tui_selwin(0);
  398.     print_configuration();
  399.  
  400.     c = tui_menubrowse(videomenu, MENU_COL_OFFSET, 5, c, MAX_MENU_HEIGHT);
  401.     if (c == -1)
  402.         break;
  403.     else switch(c) {
  404.      case 0:
  405.         tui_wgets(tmp, "Enter new video mode width", 4);
  406.         if (atoi (tmp) < 320 || atoi (tmp) > 1600 /* maybe we'll implement SHires */)
  407.         tui_errorbox("Insane value for video mode width");
  408.         else
  409.         currprefs.gfx_width = atoi (tmp);
  410.         break;
  411.      case 1:
  412.         tui_wgets(tmp, "Enter new video mode height", 4);
  413.         if (atoi (tmp) < 200 || atoi (tmp) > 800 /* whatever */)
  414.         tui_errorbox("Insane value for video mode height");
  415.         else
  416.         currprefs.gfx_height = atoi (tmp);
  417.         break;
  418.      case 2:
  419.         currprefs.color_mode++;
  420.         if (currprefs.color_mode > MAX_COLOR_MODES)
  421.         currprefs.color_mode=0;
  422.         break;
  423.      case 3:
  424.         c = tui_menubrowse(video_mode_menu, 4, 6, 0, 15);
  425.         if (c != -1)
  426.         vidmode_menu_selected(c);
  427.         c = 3;
  428.         break;
  429.      case 4:
  430.         currprefs.gfx_lores = !currprefs.gfx_lores;
  431.         break;
  432.      case 5:
  433.         currprefs.gfx_xcenter = (currprefs.gfx_xcenter + 1) % 3;
  434.         break;
  435.      case 6:
  436.         currprefs.gfx_ycenter = (currprefs.gfx_ycenter + 1) % 3;
  437.         break;
  438.      case 7:
  439.         currprefs.gfx_linedbl = !currprefs.gfx_linedbl;
  440.         break;
  441.      case 8:
  442.         currprefs.gfx_correct_aspect = !currprefs.gfx_correct_aspect;
  443.         break;
  444.      case 9:
  445.         currprefs.framerate++;
  446.         if (currprefs.framerate > 9)
  447.         currprefs.framerate=1;
  448.         break;
  449.     }
  450.     }
  451. }
  452.  
  453. static void MemoryOptions(void)
  454. {
  455.     char *tmp;
  456.     int c = 0;
  457.     for (;;) {
  458.  
  459.     tui_selwin(0);
  460.     print_configuration();
  461.  
  462.     c = tui_menubrowse(memorymenu, MENU_COL_OFFSET, 5, c, MAX_MENU_HEIGHT);
  463.     if (c == -1)
  464.         break;
  465.     else switch(c) {
  466.      case 0:
  467.         if (fastmem_size == 0)
  468.         fastmem_size = 0x200000;
  469.         else if (fastmem_size == 0x800000)
  470.         fastmem_size = 0;
  471.         else
  472.         fastmem_size <<= 1;
  473.         break;
  474.      case 1:
  475.         if (chipmem_size == 0x800000)
  476.         chipmem_size = 0x80000;
  477.         else
  478.         chipmem_size <<= 1;
  479.         if (chipmem_size > 0x200000)
  480.         fastmem_size = 0;
  481.         break;
  482.      case 2:
  483.         if (bogomem_size == 0)
  484.         bogomem_size = 0x40000;
  485.         else if (bogomem_size == 0x100000)
  486.         bogomem_size = 0;
  487.         else
  488.         bogomem_size <<= 1;
  489.         break;
  490.      case 3:
  491.         tmp = tui_filereq("*.rom", romfile, "Select a ROM image");
  492.         if (tmp != NULL)
  493.         strcpy(romfile, tmp);
  494.         break;
  495.     }
  496.     }
  497. }
  498.  
  499. static void SoundOptions(void)
  500. {
  501.     char tmp[256];
  502.     int c = 0;
  503.     for (;;) {
  504.     tui_selwin(0);
  505.     print_configuration();
  506.     c = tui_menubrowse(soundmenu, MENU_COL_OFFSET, 5, c, MAX_MENU_HEIGHT);
  507.     if (c == -1)
  508.         break;
  509.     else switch(c) {
  510.      case 0:
  511.         currprefs.produce_sound++;
  512.         if(currprefs.produce_sound > 3)
  513.         currprefs.produce_sound = 0;
  514.         break;
  515.  
  516.      case 1:
  517.         tui_wgets(tmp, "Enter new minimum sound buffer size in bytes", 6);
  518.         if (atoi (tmp) < 128 || atoi (tmp) > 65536 || atoi (tmp) > currprefs.sound_maxbsiz)
  519.         tui_errorbox("Insane value for minimum sound buffer size");
  520.         else
  521.         currprefs.sound_minbsiz = atoi (tmp);
  522.         break;
  523.  
  524.      case 2:
  525.         tui_wgets(tmp, "Enter new maximum sound buffer size in bytes", 6);
  526.         if (atoi (tmp) < 128 || atoi (tmp) > 65536 || atoi (tmp) < currprefs.sound_minbsiz)
  527.         tui_errorbox("Insane value for maximum sound buffer size");
  528.         else
  529.         currprefs.sound_maxbsiz = atoi (tmp);
  530.         break;
  531.  
  532.      case 3:
  533.         tui_wgets(tmp, "Enter new number of bits", 3);
  534.         if (atoi (tmp)!= 8 && atoi (tmp) != 16)
  535.         tui_errorbox("Unsupported number of bits");
  536.         else
  537.         currprefs.sound_bits = atoi (tmp);
  538.         break;
  539.  
  540.      case 4:
  541.         tui_wgets(tmp, "Enter new sound output frequency", 6);
  542.         if (atoi (tmp) < 11025 || atoi (tmp) > 44100)
  543.         tui_errorbox("Unsupported frequency");
  544.         else
  545.         currprefs.sound_freq = atoi (tmp);
  546.         break;
  547.     }
  548.     }
  549. }
  550.  
  551. static void OtherOptions(void)
  552. {
  553.     char tmp[256];
  554.     int c = 0;
  555.  
  556.     for (;;) {
  557.     tui_selwin (0);
  558.     print_configuration ();
  559.     c = tui_menubrowse (miscmenu, MENU_COL_OFFSET, 5, c, MAX_MENU_HEIGHT);
  560.     if (c == -1) {
  561.         break;
  562.     } else switch(c) {
  563.      case 0:
  564.         currprefs.fake_joystick = (currprefs.fake_joystick & 0xFF00) + ((currprefs.fake_joystick & 255) + 1) % 6;
  565.         if ((currprefs.fake_joystick & 255) == (currprefs.fake_joystick >> 8))
  566.         currprefs.fake_joystick = (currprefs.fake_joystick & 0x00FF) + ((((currprefs.fake_joystick >> 8) - 1) % 6) << 8);
  567.         break;
  568.      case 1:
  569.         currprefs.fake_joystick = (currprefs.fake_joystick & 0x00FF) + ((((currprefs.fake_joystick >> 8) + 1) % 6) << 8);
  570.         if ((currprefs.fake_joystick & 255) == (currprefs.fake_joystick >> 8))
  571.         currprefs.fake_joystick = (currprefs.fake_joystick & 0xFF00) + ((currprefs.fake_joystick & 255) - 1) % 6;
  572.         break;
  573.      case 2:
  574.         tui_wgets(tmp, "Enter new CPU emulation speed", 6);
  575.         if (atoi (tmp) < 1 || atoi (tmp) > 20)
  576.         tui_errorbox("Unsupported CPU emulation speed");
  577.         else
  578.         currprefs.m68k_speed = atoi (tmp);
  579.         break;
  580.     }
  581.     }
  582. }
  583.  
  584. static int do_gui(int mode)
  585. {
  586.     char cwd[1024];
  587.  
  588.     if (getcwd(cwd, 1024) == NULL)
  589.     return 0;
  590.  
  591.     tui_setup();
  592.  
  593.     for (;;) {
  594.     int c;
  595.  
  596.     tui_selwin(0);
  597.     print_configuration();
  598.     c = tui_menubrowse(mode == 0 ? mainmenu2 : mainmenu, MENU_COL_OFFSET, 4, 0, MAX_MENU_HEIGHT);
  599.     if (c == -1) {
  600.         tui_shutdown();
  601.         return -2;
  602.     }
  603.     if (mode == 1) {
  604.         if (c == 6)
  605.         break;
  606.         switch (c) {
  607.          case 0: DiskOptions (); break;
  608.          case 1: VideoOptions (); break;
  609.          case 2: MemoryOptions (); break;
  610.          case 3: HDOptions (); break;
  611.          case 4: SoundOptions (); break;
  612.          case 5: OtherOptions (); break;
  613.         }
  614.     } else {
  615.         if (c == 4)
  616.         break;
  617.         switch (c) {
  618.          case 0: DiskOptions (); break;
  619.          case 1: OtherOptions (); break;
  620.          case 2: uae_reset (); break;
  621.          case 3: uae_quit (); break;
  622.         }
  623.     }
  624.     }
  625.     tui_shutdown();
  626.  
  627.     chdir (cwd);
  628.     return 0;
  629. }
  630.  
  631. int gui_init(void)
  632. {
  633.     return do_gui(1);
  634. }
  635.  
  636. void gui_changesettings(void)
  637. {
  638.     struct uae_prefs oldprefs;
  639.     oldprefs = currprefs;
  640.  
  641.     if (do_gui(0) == -2)
  642.     uae_quit ();
  643.     else {
  644.     changed_prefs = currprefs;
  645.     currprefs = oldprefs;
  646.     currprefs.fake_joystick = changed_prefs.fake_joystick;
  647.     joystick_setting_changed ();
  648.     }
  649. }
  650.  
  651. int gui_update(void)
  652. {
  653.     return 0;
  654. }
  655.